home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 5 / Gekikoh Dennoh Club Vol. 5 (Japan).7z / Gekikoh Dennoh Club Vol. 5 (Japan) (Track 01).bin / games / rosa3 / src / rosa.c next >
Text File  |  1998-02-11  |  50KB  |  2,228 lines
  1. #include  "rosa.h"
  2. #include  "zfunc.h"
  3. #include  "graph.h"
  4.  
  5. void main();
  6. static void    PreGame(void);
  7. static void    GameMain(void);
  8. static void    Term(void);
  9. static char    MyInit(void);
  10. static void    MazeDisp(void);
  11. static void    BlockDraw(short i,short j);
  12. static void    TileDraw(short i,short j);
  13. static void    SpInit(void);
  14. static char    GameMainLoop(void);
  15. static void    MyChrMove(void);
  16. static void    DispSprite(void);
  17. static void    Gate(void);
  18. static char    Demo(void);
  19. static char    MazeLoad(void);
  20. static char    CreateEnemy(short i , short j,char Type);
  21. static char    Bgm(unsigned char i);
  22. static char    BgmRead(void);
  23. static void    Se(unsigned char i);
  24. static char    SeRead(void);
  25. static void    EnemyMain(void);
  26. static char    EnemyInit(void);
  27. static char    GateInit(void);
  28. static char    CreateGate(short i, short j);
  29. static void    EnemyOikake1(_Enemy *Enemy);
  30. static void    EnemyOikake2(_Enemy *Enemy);
  31. static void    WaitVDisp(void);
  32. static void    StageClear(void);
  33. static void    MyChrDead(void);
  34. static void    GameOver(int Y);
  35. static void    ScoreDisp(void);
  36. static void    DispStage(short Y);
  37. static void    TargetDisp(void);
  38. static void    AllClear(void);
  39.  
  40.  
  41. static _Sprite       *sp;
  42. static char          GameStatus;
  43. static unsigned char GameStage;
  44. static unsigned char *MazePtr;
  45. static unsigned int  MazeCnt;
  46. static _Enemy        *Start     =(_Enemy *)NULL
  47.                     ,*End       =(_Enemy *)NULL;
  48. static _Gate         *GateStart =(_Gate *)NULL
  49.                     ,*GateEnd   =(_Gate *)NULL;
  50. static unsigned char EnemyCnt;
  51. static char          BgmFlag;
  52. static unsigned char *BgmPtr[32];
  53. static int           BgmSize[32];
  54. static unsigned char *SePtr[32];
  55. static int           SeSize[32];
  56. static short         CursorY;
  57. static char          PushFlag;
  58. static unsigned int  Score;
  59. static unsigned int  HiScore=10000;
  60. static char          MyLeft;
  61. static char          EnemyDownFlag;
  62. static unsigned char ContinueCnt=0;
  63. static unsigned int  ContinueMazeCnt;
  64. static unsigned int  ExtendEvery = 0;
  65. static unsigned int  AnimeCnt = 0;
  66. static char          PushAFlag;
  67. static int           EnemyDownRate;
  68. static short         TargetX;
  69. static short         TargetY;
  70. static short         TargetTimer;
  71. static short         GateCloseCnt;
  72. static char          PcmFlag;
  73. static int             StageHiScore[50];
  74. static int             StageScore;
  75.  
  76.  
  77. static void
  78. AllClear()
  79. {
  80.  
  81.  
  82.   int Loop;
  83.   int i;
  84.   int LoopI;
  85.   unsigned short Ptn;
  86.   unsigned char  Cnt;
  87.  
  88.  
  89.   BGTEXTCL(1,0x0100);
  90.  
  91.   Bgm(5);
  92.  
  93.   for (Loop=0;Loop<4;Loop++) {
  94.  
  95.   Cnt=0;
  96.   for (i=274;i> -80;i-=1) {
  97.   
  98.      SpInit();
  99.      sp = &Sprite[0];
  100.  
  101.      for (LoopI=0;LoopI<4;LoopI++) {
  102.        sp->X   = 56+(LoopI*16);
  103.        sp->Y   = 32;
  104.        sp->Ptn = 0x0590+LoopI;
  105.        sp->Pri = 3;
  106.        sp++;
  107.      }
  108.  
  109.      sp->X   = 120;
  110.      sp->Y   = 32;
  111.      sp->Ptn = 0x0594;
  112.      sp->Pri = 3;
  113.      sp++;
  114.  
  115.     for (LoopI=0;LoopI<4;LoopI++) {
  116.       sp->X   = 136+(LoopI*16);
  117.       sp->Y   = 32;
  118.       sp->Ptn = 0x0590+LoopI;
  119.       sp->Pri = 3;
  120.       sp++;
  121.     }
  122.  
  123.     sp->X   = 216;
  124.     sp->Y   = 32;
  125.     sp->Ptn = 0x0595;
  126.     sp->Pri = 3;
  127.     sp++;
  128.  
  129.     for (LoopI=0;LoopI<6;LoopI++) {
  130.       sp->X   = 96+(LoopI*16);
  131.       sp->Y   = 96;
  132.       sp->Ptn = 0x05b3+LoopI;
  133.       sp->Pri = 3;
  134.       sp++;
  135.     }
  136.     
  137.     
  138.     Cnt++;
  139.     if (Cnt ==28) Cnt=0;
  140.     
  141.     Ptn=0x0170+(Cnt/4);
  142.  
  143.     sp->X   = i+20;
  144.     sp->Y   = 128+(Loop*16)-16;
  145.     sp->Ptn = Ptn-0x10;
  146.     sp->Pri = 3;
  147.     sp++;
  148.     sp->X   = i+20;
  149.     sp->Y   = 128+(Loop*16);
  150.     sp->Ptn = Ptn;
  151.     sp->Pri = 3;
  152.     sp++;
  153.     
  154.     
  155.     Ptn=0x0667+(Cnt/7);
  156.     sp->X   = i+60;
  157.     sp->Y   = 128+(Loop*16);
  158.     sp->Ptn = Ptn;
  159.     sp->Pri = 3;
  160.     sp++;
  161.     
  162.     Ptn=0x0767+(Cnt/7);
  163.     sp->X   = i+76;
  164.     sp->Y   = 128+(Loop*16);
  165.     sp->Ptn = Ptn;
  166.     sp->Pri = 3;
  167.     sp++;
  168.  
  169.     for (LoopI=0;LoopI<6;LoopI++) {
  170.       sp->X   = 96+(LoopI*16);
  171.       sp->Y   = 208;
  172.       sp->Ptn = 0x05B9+LoopI;
  173.       sp->Pri = 3;
  174.       sp++;
  175.     }
  176.  
  177.     
  178.     ScoreDisp();
  179.     DispSprite();
  180.   }
  181.  
  182.   Cnt=0;
  183.   for (i=-80;i<274;i++) {
  184.  
  185.      SpInit();
  186.      sp = &Sprite[0];
  187.  
  188.      for (LoopI=0;LoopI<4;LoopI++) {
  189.        sp->X   = 56+(LoopI*16);
  190.        sp->Y   = 32;
  191.        sp->Ptn = 0x0590+LoopI;
  192.        sp->Pri = 3;
  193.        sp++;
  194.      }
  195.  
  196.      sp->X   = 120;
  197.      sp->Y   = 32;
  198.      sp->Ptn = 0x0594;
  199.      sp->Pri = 3;
  200.      sp++;
  201.  
  202.     for (LoopI=0;LoopI<4;LoopI++) {
  203.       sp->X   = 136+(LoopI*16);
  204.       sp->Y   = 32;
  205.       sp->Ptn = 0x0590+LoopI;
  206.       sp->Pri = 3;
  207.       sp++;
  208.     }
  209.  
  210.     sp->X   = 216;
  211.     sp->Y   = 32;
  212.     sp->Ptn = 0x0595;
  213.     sp->Pri = 3;
  214.     sp++;
  215.  
  216.     for (LoopI=0;LoopI<6;LoopI++) {
  217.       sp->X   = 96+(LoopI*16);
  218.       sp->Y   = 96;
  219.       sp->Ptn = 0x05b3+LoopI;
  220.       sp->Pri = 3;
  221.       sp++;
  222.     }
  223.     
  224.     
  225.     Cnt++;
  226.     if (Cnt ==28) Cnt=0;
  227.     
  228.     Ptn=0x0157+(Cnt/4);
  229.  
  230.     sp->X   = i+56;
  231.     sp->Y   = 128+(Loop*16)-16;
  232.     sp->Ptn = Ptn-0x10;
  233.     sp->Pri = 3;
  234.     sp++;
  235.     sp->X   = i+56;
  236.     sp->Y   = 128+(Loop*16);
  237.     sp->Ptn = Ptn;
  238.     sp->Pri = 3;
  239.     sp++;
  240.     
  241.     
  242.     Ptn=0x066B+(Cnt/7);
  243.     sp->X   = i;
  244.     sp->Y   = 128+(Loop*16);
  245.     sp->Ptn = Ptn;
  246.     sp->Pri = 3;
  247.     sp++;
  248.     
  249.     Ptn=0x076B+(Cnt/7);
  250.     sp->X   = i+16;
  251.     sp->Y   = 128+(Loop*16);
  252.     sp->Ptn = Ptn;
  253.     sp->Pri = 3;
  254.     sp++;
  255.  
  256.     for (LoopI=0;LoopI<6;LoopI++) {
  257.       sp->X   = 96+(LoopI*16);
  258.       sp->Y   = 208;
  259.       sp->Ptn = 0x05B9+LoopI;
  260.       sp->Pri = 3;
  261.       sp++;
  262.     }
  263.  
  264.     ScoreDisp();
  265.     DispSprite();
  266.   }
  267. }
  268.  
  269.  
  270.   FadeOut(10);
  271.  
  272.   for (i=0;i<400;i++) {
  273.     WaitVDisp();
  274.   }
  275.   
  276. }
  277.  
  278.  
  279.  
  280. void
  281. TargetDisp(void)
  282. {
  283.     if (TargetTimer > 400) return;
  284.  
  285.     TargetTimer++;
  286.  
  287.     if (My->X == TargetX && My->Y == TargetY) {
  288.       Score      += (((GameStage-1)&7)+1)*3000;
  289.       StageScore += (((GameStage-1)&7)+1)*3000;
  290.       TargetTimer = 1000;
  291.       Se(5);
  292.       PcmFlag = -1;
  293.     }
  294.  
  295.     if (TargetTimer > 300) {
  296.       if (!(TargetTimer&1)) return;
  297.     }
  298.  
  299.     sp->X   = TargetX;
  300.     sp->Y   = TargetY;
  301.     sp->Ptn = 0x08A0+((GameStage-1)&7);
  302.     if (((GameStage-1)&7)==7) sp->Ptn += 0x0100;
  303.     sp->Pri = 3;
  304.     sp++;
  305. }
  306.  
  307.  
  308. void
  309. main()
  310. {
  311.   int i;
  312.  
  313.   char *OpmName = "OPM";
  314.   int  hOpm;
  315.  
  316.   hOpm = OPEN(OpmName,0x001);    /* ôKôûé╚ÅφÆôâ`âFâbâNé┼é╖ */
  317.   if (hOpm < 0) {
  318.      printf("âTâEâôâhüEâhâëâCâoé¬ÅφÆôé╡é─éóé▄é╣é±üBÅIù╣é╡é▄é╖\n");
  319.      EXIT();
  320.   }
  321.   CLOSE(hOpm);
  322.  
  323.  
  324.   for (i=0;i<32;i++) {
  325.     BgmPtr[i] = (unsigned char *)NULL;
  326.     SePtr[i]  = (unsigned char *)NULL;
  327.   }
  328.   MazePtr = (unsigned char *)NULL;
  329.  
  330.   if (!MazeLoad())  Term();
  331.   if (!BgmRead())   Term();
  332.   if (!SeRead())    Term();
  333.  
  334.   PreGame();
  335.   GameMain();
  336.   Term();
  337. }
  338.  
  339. static void
  340. PreGame(void)
  341. {
  342.   int i;
  343.  
  344.   B_SUPER(0);
  345.  
  346.  
  347.   CRTMOD(10);
  348.   G_CLR_ON();
  349.   B_CUROFF();
  350.   SP_OFF();
  351.   SpInit();
  352.   DispSprite();
  353.   BGCTRLST(1,1,1);
  354.   BGSCRLST(1,0,0);
  355.   BGTEXTCL(1,0x0100);
  356.   SP_ON();
  357.  
  358.   Bgm(0);
  359.   for  (i=0;i<30;i++)  WaitVDisp(); /* ë╣ÉFÉ▌ÆΦé▄é┼é╠ï≤âïü[âv */
  360.  
  361. }
  362.  
  363. static void
  364. GameMain(void)
  365. {
  366.  
  367.  
  368.   FILE *FilePtr;
  369.   int i;
  370.  
  371.   for (i=0;i<50;i++) {
  372.     StageHiScore[i]=0;
  373.   }
  374.  
  375.   /* Score Load */
  376.   FilePtr = fopen("Hisc.dat","rb");
  377.   if (FilePtr != NULL) {
  378.     fread(&HiScore,sizeof(int),1,FilePtr);
  379.     for (i=0;i<50;i++) {
  380.       fread(&StageHiScore[i],sizeof(int),1,FilePtr);
  381.     }
  382.   }
  383.  
  384.   if (!MyInit())    Term();
  385.   if (!EnemyInit()) Term();
  386.   if (!GateInit())  Term();
  387.  
  388.   GameStatus = 0;
  389.   BgmFlag    = 0;
  390.  
  391.   while ( !(GameMainLoop()) );
  392. }
  393.  
  394. static void
  395. Term(void)
  396. {
  397.   _Gate  *GatePtr,*GateDummy;
  398.   _Enemy *Enemy,*EnemyDummy;
  399.   int i;
  400.   int DriveType;
  401.  
  402.  
  403.   FILE   *FilePtr;
  404.  
  405.   BgmStop();
  406.  
  407.   /* Protect Check. */
  408.   DriveType = DRVCTRL(0,0);
  409.   DriveType &= 0x08;
  410.  
  411.   /* Score Save */
  412.   if (!DriveType) { /* No Protect */
  413.     FilePtr = fopen("Hisc.dat","wb");
  414.     if (FilePtr != NULL) {
  415.       fwrite(&HiScore,sizeof(int),1,FilePtr);
  416.       for (i=0;i<50;i++) {
  417.         fwrite(&StageHiScore[i],sizeof(int),1,FilePtr);
  418.       }
  419.         }
  420.     fclose (FilePtr);
  421.   }
  422.  
  423.   if (MazePtr != NULL) free(MazePtr);
  424.  
  425.   for (i=0;i<32;i++) {
  426.     if (BgmPtr[i] != NULL)  free(BgmPtr[i]);
  427.     if (SePtr[i]  != NULL)  free(SePtr[i]);
  428.   }
  429.  
  430.   if (My != NULL) free(My);
  431.  
  432.   if (GateStart != NULL  && GateEnd != NULL)  {
  433.     GatePtr = GateStart->Next;
  434.     while (GatePtr->Next != NULL) {
  435.       GateDummy           = GatePtr;
  436.       GatePtr->Prev->Next = GatePtr->Next;
  437.       GatePtr->Next->Prev = GatePtr->Prev;
  438.       GatePtr             = GatePtr->Next;
  439.       free(GateDummy);
  440.     }
  441.   }
  442.  
  443.   if (GateStart != NULL) free(GateStart);
  444.   if (GateEnd   != NULL) free(GateEnd);
  445.  
  446.   if (Start != NULL && End != NULL) {
  447.     Enemy = Start->Next;
  448.     while (Enemy->Next != NULL) {
  449.       EnemyDummy        = Enemy;
  450.       Enemy->Prev->Next = Enemy->Next;
  451.       Enemy->Next->Prev = Enemy->Prev;
  452.       Enemy             = Enemy->Next;
  453.       free(EnemyDummy);
  454.     }
  455.   }
  456.  
  457.   if (Start != NULL) free(Start);
  458.   if (End   != NULL) free(End);
  459.  
  460.  
  461.   KFLUSHIO( 0xFE );
  462.   CRTMOD(16);
  463.   G_CLR_ON();
  464.   B_CURON();
  465.   
  466.   EXIT();
  467. }
  468.  
  469. static void
  470. SpInit(void)
  471. {
  472.   int i;
  473.   
  474.   (_Sprite *)sp = (_Sprite *)Sprite;
  475.  
  476.   for (i=0;i<128;i++) {
  477.     sp->Pri = 0;
  478.     sp++;
  479.   }
  480. }
  481.  
  482. static char
  483. GameMainLoop(void)
  484. {
  485.   _Gate  *GatePtr,*Dummy;
  486.   _Enemy *Enemy,*EnemyDummy;
  487.   int    i=0;
  488.   short  Y;
  489.  
  490.   if ( *(char *)0x080C == 0x02) return -1;
  491.  
  492.   switch (GameStatus) {
  493.     case 0:{
  494.       SpInit();
  495.       (_Sprite *)sp = (_Sprite *)Sprite;
  496.       if (!BgmFlag)  {
  497.         if (!Bgm(1)) Term();
  498.         PushAFlag = -1;
  499.         MazeCnt = 0;
  500.         CursorY = 224;
  501.         if (ContinueCnt) CursorY = 208;
  502.         /* MazeDisp(); */
  503.         BGTEXTCL(1,0x0100);
  504.         
  505.       }
  506.       if (Demo()) return -1;
  507.       return 0;
  508.     }
  509.     case 1:{
  510.       PcmFlag=0;
  511.       if (!BgmFlag) {
  512.           SpInit();
  513.           (_Sprite *)sp = &Sprite[5];
  514.           
  515.           TargetX      = My->X;
  516.           TargetY      = My->Y;
  517.           GateCloseCnt = 0;
  518.           TargetTimer  = 1000;
  519.           
  520.           StageScore   = 0;
  521.           
  522.           MyChrMove();
  523.           EnemyMain();
  524.           Gate();
  525.           ScoreDisp();
  526.           Bgm(2);
  527.           for (Y=256;Y>24;Y-=3) {
  528.               DispStage(Y);
  529.               DispSprite();
  530.           }
  531.       } else {
  532.           SpInit();
  533.           (_Sprite *)sp = &Sprite[5];
  534.           MyChrMove();
  535.           EnemyMain();
  536.           TargetDisp();
  537.           Gate();
  538.           ScoreDisp();
  539.           DispStage(24);
  540.           DispSprite();
  541.       }
  542.       BgmFlag = 1;
  543.       if (!EnemyCnt)  {
  544.          GameStatus = 2;
  545.       }
  546.       if (GameStatus == 6) BgmFlag = 0;
  547.       if (*(char *)0x0800 == 0x02) GameStatus = 3;
  548.       if (*(char *)0x0804 == 0x04) {
  549.         BgmFlag    = 0;
  550.         GameStatus = 6;
  551.       }
  552.       return 0;
  553.     }
  554.     case 2: {
  555.       StageClear();
  556.       
  557.       
  558.       GatePtr = GateStart->Next;
  559.       while (GatePtr->Next != NULL) {
  560.         Dummy    = GatePtr;
  561.         GatePtr->Prev->Next = GatePtr->Next;
  562.         GatePtr->Next->Prev = GatePtr->Prev;
  563.         GatePtr  = GatePtr->Next;
  564.         free(Dummy);
  565.       }
  566.       GameStage++;
  567.       GameStatus = 1;
  568.       BgmFlag    = 0;
  569.       ContinueMazeCnt = MazeCnt;
  570.       MazeDisp();
  571.       return 0;
  572.     }
  573.     case 3: {
  574.       if (*(char *)0x0800 != 0x02) GameStatus = 4;
  575.       return 0;
  576.     }
  577.     case 4: {
  578.       if (*(char *)0x0800 == 0x02) GameStatus = 5;
  579.       return 0;
  580.     }
  581.     case 5: {
  582.       if (*(char *)0x0800 != 0x02) GameStatus = 1;
  583.       return 0;
  584.     }
  585.     case 6: {
  586.       if (!BgmFlag) if (!Bgm(3)) Term();
  587.       BgmFlag = 1;
  588.       MyChrDead();
  589.       MyLeft--;
  590.       if (MyLeft < 0) GameStatus = 7;
  591.       My->X = My->InitX;
  592.       My->Y = My->InitY;
  593.       if (GameStatus != 7) {
  594.         Enemy = Start->Next;
  595.         while (Enemy->Next != NULL) {
  596.           Enemy->X = Enemy->InitX;
  597.           Enemy->Y = Enemy->InitY;
  598.           Enemy->Houkou  = 0;
  599.           Enemy->Cnt     = 0;
  600.           Enemy->DownCnt = 0;
  601.           Enemy = Enemy->Next;
  602.         }
  603.       }
  604.  
  605.       GatePtr = GateStart->Next;
  606.       while (GatePtr->Next != NULL) {
  607.         GatePtr->Status   = 5;
  608.         GatePtr->OpenFlag = 0;
  609.         GatePtr           = GatePtr->Next;
  610.       }
  611.       BgmFlag=0;
  612.       return 0;
  613.     }
  614.     case 7: {
  615.       for (Y=0;Y<128;Y++) {
  616.       
  617.           SpInit();
  618.           (_Sprite *)sp = &Sprite[5];
  619.           GameOver(Y);
  620.           ScoreDisp();
  621.           EnemyMain();
  622.           Gate();
  623.           DispStage(24);
  624.           DispSprite();
  625.       }
  626.       
  627.       i=0;
  628.       while (i<120) {
  629.         WaitVDisp();
  630.         i++;
  631.       }
  632.       GatePtr = GateStart->Next;
  633.       while (GatePtr->Next != NULL) {
  634.         Dummy    = GatePtr;
  635.         GatePtr->Prev->Next = GatePtr->Next;
  636.         GatePtr->Next->Prev = GatePtr->Prev;
  637.         GatePtr  = GatePtr->Next;
  638.         free(Dummy);
  639.       }
  640.       Enemy = Start->Next;
  641.       while (Enemy->Next != NULL) {
  642.         EnemyDummy        = Enemy;
  643.         Enemy->Prev->Next = Enemy->Next;
  644.         Enemy->Next->Prev = Enemy->Prev;
  645.         Enemy             = Enemy->Next;
  646.         free(EnemyDummy);
  647.       }
  648.       GameStatus = 0;
  649.       return 0;
  650.     }
  651.   }
  652.   return 0;
  653. }
  654.  
  655.  
  656. static void
  657. StageClear(void)
  658. {
  659.   unsigned short Ptn;
  660.   unsigned int   i=0;
  661.   char           BestDisp=0;
  662.  
  663.   unsigned char LoopI=0;
  664.   unsigned int  Point;
  665.   unsigned int  Temp;
  666.   unsigned int  DummyScore;
  667.  
  668.   BestDisp = 0;
  669.   if (StageScore > StageHiScore[GameStage-1]) {
  670.     StageHiScore[GameStage-1] = StageScore;
  671.     BestDisp = 1;
  672.   }
  673.  
  674.  
  675.  
  676.   while (i<80) {
  677.      SpInit();
  678.      (_Sprite *)sp = &Sprite[5];
  679.  
  680.      DispStage(24);
  681.  
  682. /* Stage Result. */
  683.  
  684.  
  685.   if (BestDisp) {
  686.   
  687.     if ((i%10)<5) {
  688.       for (LoopI=0;LoopI<3;LoopI++) {
  689.         sp->X   = 64+(LoopI*16);
  690.         sp->Y   = 128;
  691.         sp->Ptn = 0x05B0+LoopI;
  692.         sp->Pri = 3;
  693.         sp++;
  694.       }
  695.     }
  696.   }
  697.  
  698.  
  699.   sp->X   = 64;
  700.   sp->Y   = 64;
  701.   sp->Ptn = 0x04A8;
  702.   sp->Pri = 3;
  703.   sp++;
  704.   sp->X   = 80;
  705.   sp->Y   = 64;
  706.   sp->Ptn = 0x04A9;
  707.   sp->Pri = 3;
  708.   sp++;
  709.  
  710.   sp->X   = 64;
  711.   sp->Y   = 96;
  712.   sp->Ptn = 0x04AA;
  713.   sp->Pri = 3;
  714.   sp++;
  715.   sp->X   = 80;
  716.   sp->Y   = 96;
  717.   sp->Ptn = 0x04AB;
  718.   sp->Pri = 3;
  719.   sp++;
  720.  
  721.   LoopI=0;
  722.   Point = 1000000;
  723.   DummyScore = StageHiScore[GameStage-1];
  724.   while (LoopI<7) {
  725.     if (DummyScore >= Point) {
  726.        Temp       = DummyScore/Point;
  727.        DummyScore -= (Temp*Point);
  728.        sp->X      = 104+(LoopI*8);
  729.        sp->Y      = 64;
  730.        sp->Ptn    = 0x0414+Temp;
  731.        sp->Pri    = 3;
  732.        sp++;
  733.     } else {
  734.        sp->X      = 104+(LoopI*8);
  735.        sp->Y      = 64;
  736.        sp->Ptn    = 0x0414;
  737.        sp->Pri    = 3;
  738.        sp++;
  739.     }
  740.     Point = Point / 10;
  741.     LoopI++;
  742.   }
  743.  
  744.   
  745.   LoopI=0;
  746.   Point = 1000000;
  747.   DummyScore = StageScore;
  748.   while (LoopI<7) {
  749.     if (DummyScore >= Point) {
  750.        Temp       = DummyScore/Point;
  751.        DummyScore -= (Temp*Point);
  752.        sp->X      = 104+(LoopI*8);
  753.        sp->Y      = 96;
  754.        sp->Ptn    = 0x0414+Temp;
  755.        sp->Pri    = 3;
  756.        sp++;
  757.     } else {
  758.        sp->X   = 104+(LoopI*8);
  759.        sp->Y   = 96;
  760.        sp->Ptn = 0x0414;
  761.        sp->Pri = 3;
  762.        sp++;
  763.     }
  764.     Point = Point / 10;
  765.     LoopI++;
  766.   }
  767.  
  768.  
  769.     if ((i%20)<10) {
  770.       Ptn=0x0129;
  771.     } else {
  772.       Ptn=0x012A;
  773.     }
  774.  
  775.     sp->X   = My->X;
  776.     sp->Y   = My->Y;
  777.     sp->Ptn = Ptn+0x10;
  778.     sp->Pri = 3;
  779.     sp++;
  780.     sp->X   = My->X;
  781.     sp->Y   = My->Y-16;
  782.     sp->Ptn = Ptn;
  783.     sp->Pri = 3;
  784.     sp++;
  785.  
  786.  
  787.     Gate();
  788.     ScoreDisp();
  789.  
  790.     DispSprite();
  791.     i++;
  792.   }
  793.   
  794.   for (i=0;i<40;i++) {
  795.     WaitVDisp();
  796.   }
  797. }
  798.  
  799. static void
  800. MyChrDead(void)
  801. {
  802.   int i=0;
  803.   unsigned short Ptn;
  804.  
  805.   while (i<60) {
  806.      SpInit();
  807.      (_Sprite *)sp = &Sprite[5];
  808.  
  809.      DispStage(24);
  810.  
  811.     if ((i%20)<10) {
  812.       Ptn=0x012B;
  813.     } else {
  814.       Ptn=0x012C;
  815.     }
  816.  
  817.     sp->X   = My->X;
  818.     sp->Y   = My->Y;
  819.     sp->Ptn = Ptn+0x10;
  820.     sp->Pri = 3;
  821.     sp++;
  822.     sp->X   = My->X;
  823.     sp->Y   = My->Y-16;
  824.     sp->Ptn = Ptn;
  825.     sp->Pri = 3;
  826.     sp++;
  827.  
  828.     EnemyMain();
  829.     Gate();
  830.     ScoreDisp();
  831.  
  832.     DispSprite();
  833.     i++;
  834.   }
  835.   GameStatus = 1;
  836. }
  837.  
  838.  
  839. static void
  840. ScoreDisp()
  841. {
  842.   unsigned char i;
  843.   unsigned int  Point;
  844.   unsigned int  Temp;
  845.   unsigned int  DummyScore;
  846.   char          DummyLeft;
  847.  
  848.   sp->X   = 16+8;
  849.   sp->Y   = 256;
  850.   sp->Ptn = 0x040A;
  851.   sp->Pri = 3;
  852.   sp++;
  853.   sp->X   = 32+8;
  854.   sp->Y   = 256;
  855.   sp->Ptn = 0x040B;
  856.   sp->Pri = 3;
  857.   sp++;
  858.  
  859.   sp->X   = 128;
  860.   sp->Y   = 256;
  861.   sp->Ptn = 0x040C;
  862.   sp->Pri = 3;
  863.   sp++;
  864.   sp->X   = 144;
  865.   sp->Y   = 256;
  866.   sp->Ptn = 0x040D;
  867.   sp->Pri = 3;
  868.   sp++;
  869.  
  870.   sp->X   = 216;
  871.   sp->Y   = 256;
  872.   sp->Ptn = 0x040E;
  873.   sp->Pri = 3;
  874.   sp++;
  875.   sp->X   = 232;
  876.   sp->Y   = 256;
  877.   sp->Ptn = 0x040F;
  878.   sp->Pri = 3;
  879.   sp++;
  880.  
  881.   i=0;
  882.   Point = 1000000;
  883.   DummyScore = Score;
  884.   while (i<7) {
  885.     if (DummyScore >= Point) {
  886.        Temp       = DummyScore/Point;
  887.        DummyScore -= (Temp*Point);
  888.        sp->X      = 48+(i*8)+8;
  889.        sp->Y      = 256;
  890.        sp->Ptn    = 0x0414+Temp;
  891.        sp->Pri    = 3;
  892.        sp++;
  893.     } else {
  894.        sp->X      = 48+(i*8)+8;
  895.        sp->Y      = 256;
  896.        sp->Ptn    = 0x0414;
  897.        sp->Pri    = 3;
  898.        sp++;
  899.     }
  900.     Point = Point / 10;
  901.     i++;
  902.   }
  903.  
  904.   if (Score > HiScore) HiScore = Score;
  905.   
  906.   
  907.   while (ExtendEvery < Score) {
  908.       ExtendEvery *=2;
  909.       MyLeft++;
  910.   }
  911.   
  912.   i=0;
  913.   Point = 1000000;
  914.   DummyScore = HiScore;
  915.   while (i<7) {
  916.     if (DummyScore >= Point) {
  917.        Temp       = DummyScore/Point;
  918.        DummyScore -= (Temp*Point);
  919.        sp->X      = 160+(i*8);
  920.        sp->Y      = 256;
  921.        sp->Ptn    = 0x0414+Temp;
  922.        sp->Pri    = 3;
  923.        sp++;
  924.     } else {
  925.        sp->X   = 160+(i*8);
  926.        sp->Y   = 256;
  927.        sp->Ptn = 0x0414;
  928.        sp->Pri = 3;
  929.        sp++;
  930.     }
  931.     Point = Point / 10;
  932.     i++;
  933.   }
  934.   
  935.  
  936.   i=0;
  937.   Point = 10;
  938.   DummyLeft = MyLeft;
  939.   if (DummyLeft < 0) DummyLeft = 0; /*üEüEüEôKôûé╚Åêù¥*/
  940.   while (i<2) {
  941.     if (DummyLeft >= Point) {
  942.        Temp       = DummyLeft/Point;
  943.        DummyLeft -= (Temp*Point);
  944.        sp->X      = 248+(i*8);
  945.        sp->Y      = 256;
  946.        sp->Ptn    = 0x0414+Temp;
  947.        sp->Pri    = 3;
  948.        sp++;
  949.     } else {
  950.        sp->X      = 248+(i*8);
  951.        sp->Y      = 256;
  952.        sp->Ptn    = 0x0414;
  953.        sp->Pri    = 3;
  954.        sp++;
  955.     }
  956.     Point = Point / 10;
  957.     i++;
  958.   }
  959.  
  960.  
  961. }
  962.  
  963. static void
  964. DispStage(short Y)
  965. {
  966.  
  967.  
  968.   unsigned char i;
  969.   unsigned int  Point;
  970.   unsigned int  Temp;
  971.   unsigned int  DummyStage;
  972.  
  973.   _Sprite *Sp;
  974.   (_Sprite *)Sp = &Sprite[0];
  975.  
  976.   Sp->X   = Y;
  977.   Sp->Y   = 18;
  978.   Sp->Ptn = 0x0583;
  979.   Sp->Pri = 3;
  980.   Sp++;
  981.   Sp->X   = Y+16;
  982.   Sp->Y   = 18;
  983.   Sp->Ptn = 0x0584;
  984.   Sp->Pri = 3;
  985.   Sp++;
  986.   Sp->X   = Y+32;
  987.   Sp->Y   = 18;
  988.   Sp->Ptn = 0x0585;
  989.   Sp->Pri = 3;
  990.   Sp++;
  991.  
  992.   i=0;
  993.   Point = 10;
  994.   DummyStage = GameStage;
  995.   while (i<2) {
  996.     if (DummyStage >= Point) {
  997.        Temp       = DummyStage/Point;
  998.        DummyStage -= (Temp*Point);
  999.        Sp->X      = Y+48+(i*8);
  1000.        Sp->Y      = 18;
  1001.        Sp->Ptn    = 0x0414+Temp;
  1002.        Sp->Pri    = 3;
  1003.        Sp++;
  1004.     } else {
  1005.        Sp->X      = Y+48+(i*8);
  1006.        Sp->Y      = 18;
  1007.        Sp->Ptn    = 0x0414;
  1008.        Sp->Pri    = 3;
  1009.        Sp++;
  1010.     }
  1011.     Point = Point / 10;
  1012.     i++;
  1013.   }
  1014. }
  1015.  
  1016. static unsigned char
  1017. GetKeyPort()
  1018. {
  1019.   unsigned char KeyPort = *(unsigned char *)0xE9A001;
  1020.  
  1021.   if ( KeyPort == 0xFF ) { 
  1022.     if ((*(unsigned char *)0x0807 & 0x10) == 0x10 ) KeyPort &= 0xFE;
  1023.     if ((*(unsigned char *)0x0807 & 0x40) == 0x40 ) KeyPort &= 0xFD;
  1024.     if ((*(unsigned char *)0x0807 & 0x08) == 0x08 ) KeyPort &= 0xFB;
  1025.     if ((*(unsigned char *)0x0807 & 0x20) == 0x20 ) KeyPort &= 0xF7;
  1026.     if ((*(unsigned char *)0x080A & 0x20) == 0x20 ) KeyPort &= 0x2F;
  1027.     if ((*(unsigned char *)0x080A & 0x40) == 0x40 ) KeyPort &= 0x4F;
  1028.   }
  1029.  
  1030.   return KeyPort;
  1031. }
  1032.  
  1033.  
  1034. static char
  1035. Demo(void)
  1036. {
  1037.   int i;
  1038.  
  1039.   unsigned char KeyPort = GetKeyPort();
  1040.  
  1041.  
  1042.   /* â^âCâgâïò\Ī */
  1043.  
  1044.   for (i=0;i<4;i++) {
  1045.     sp->X   = 56+(i*16);
  1046.     sp->Y   = 32;
  1047.     sp->Ptn = 0x0590+i;
  1048.     sp->Pri = 3;
  1049.     sp++;
  1050.   }
  1051.  
  1052.   sp->X   = 120;
  1053.   sp->Y   = 32;
  1054.   sp->Ptn = 0x0594;
  1055.   sp->Pri = 3;
  1056.   sp++;
  1057.  
  1058.   for (i=0;i<4;i++) {
  1059.     sp->X   = 136+(i*16);
  1060.     sp->Y   = 32;
  1061.     sp->Ptn = 0x0590+i;
  1062.     sp->Pri = 3;
  1063.     sp++;
  1064.   }
  1065.  
  1066.   sp->X   = 216;
  1067.   sp->Y   = 32;
  1068.   sp->Ptn = 0x0595;
  1069.   sp->Pri = 3;
  1070.   sp++;
  1071.  
  1072.  
  1073.   /* âLâââëò\Ī */
  1074.   
  1075.   /*  Rosa */
  1076.   sp->X   = 104;
  1077.   sp->Y   = 80;
  1078.   sp->Ptn = 0x0128;
  1079.   sp->Pri = 3;
  1080.   sp++;
  1081.   sp->X   = 104;
  1082.   sp->Y   = 96;
  1083.   sp->Ptn = 0x0138;
  1084.   sp->Pri = 3;
  1085.   sp++;
  1086.   for (i=0;i<3;i++) {
  1087.     sp->X   = 136+(i*16);
  1088.     sp->Y   = 96;
  1089.     sp->Ptn = 0x0596+i;
  1090.     sp->Pri = 3;
  1091.     sp++;
  1092.   }
  1093.  
  1094.   /* Monster */
  1095.   sp->X   = 104;
  1096.   sp->Y   = 120;
  1097.   sp->Ptn = 0x0677;
  1098.   sp->Pri = 3;
  1099.   sp++;
  1100.   for (i=0;i<3;i++) {
  1101.     sp->X   = 136+(i*16);
  1102.     sp->Y   = 120;
  1103.     sp->Ptn = 0x0599+i;
  1104.     sp->Pri = 3;
  1105.     sp++;
  1106.   }
  1107.   /* Monster */
  1108.   sp->X   = 104;
  1109.   sp->Y   = 144;
  1110.   sp->Ptn = 0x0777;
  1111.   sp->Pri = 3;
  1112.   sp++;
  1113.   for (i=0;i<3;i++) {
  1114.     sp->X   = 136+(i*16);
  1115.     sp->Y   = 144;
  1116.     sp->Ptn = 0x0599+i;
  1117.     sp->Pri = 3;
  1118.     sp++;
  1119.   }
  1120.  
  1121.   /* Gate */
  1122.   sp->X   = 104;
  1123.   sp->Y   = 168;
  1124.   sp->Ptn = 0x0203;
  1125.   sp->Pri = 3;
  1126.   sp++;
  1127.   for (i=0;i<2;i++) {
  1128.     sp->X   = 136+(i*16);
  1129.     sp->Y   = 168;
  1130.     sp->Ptn = 0x059C+i;
  1131.     sp->Pri = 3;
  1132.     sp++;
  1133.   }
  1134.  
  1135.  
  1136.   if (PushAFlag == -1) {
  1137.     if ((KeyPort&0x40)!=0 && (KeyPort&0x20)!=0)  PushAFlag = 0;
  1138.   }
  1139.  
  1140.  
  1141.   for (i=0;i<3;i++) {
  1142.     sp->X   = 120+(i*16);
  1143.     sp->Y   = 224;
  1144.     sp->Ptn = 0x052d+i;
  1145.     sp->Pri = 3;
  1146.     sp++;
  1147.   }
  1148.   for (i=0;i<2;i++) {
  1149.     sp->X   = 120+(i*16);
  1150.     sp->Y   = 240;
  1151.     sp->Ptn = 0x053d+i;
  1152.     sp->Pri = 3;
  1153.     sp++;
  1154.   }
  1155.   
  1156.   if (ContinueCnt) {
  1157.     for (i=0;i<3;i++) {
  1158.       sp->X   = 120+(i*16);
  1159.       sp->Y   = 208;
  1160.       sp->Ptn = 0x0580+i;
  1161.       sp->Pri = 3;
  1162.       sp++;
  1163.     }
  1164.   
  1165.     sp->X      = 168;
  1166.     sp->Y      = 208;
  1167.     sp->Ptn    = 0x0414+ContinueCnt;
  1168.     sp->Pri    = 3;
  1169.     sp++;
  1170.   }
  1171.   
  1172.   if (PushFlag) {
  1173.     if (((KeyPort&0x01)!=0) && ((KeyPort&0x02)!=0)) PushFlag = 0;
  1174.   }
  1175.  
  1176.   if (((KeyPort & 0x01) == 0) && (!PushFlag) ) {
  1177.     CursorY  -= 16;
  1178.     if (CursorY < 224) {
  1179.       if (ContinueCnt) { 
  1180.         CursorY = 208;
  1181.       } else {
  1182.         CursorY = 240;
  1183.       }
  1184.     }
  1185.     PushFlag = -1;
  1186.   }
  1187.  
  1188.   if (((KeyPort & 0x02) == 0) && (!PushFlag) ) {
  1189.     CursorY  += 16;
  1190.     if (CursorY > 240 ) { 
  1191.       if (ContinueCnt) {
  1192.         CursorY = 208;
  1193.       } else {
  1194.         CursorY = 224;
  1195.       }
  1196.     }
  1197.     PushFlag = -1;
  1198.   }
  1199.  
  1200.   sp->X   = 104;
  1201.   sp->Y   = CursorY;
  1202.   sp->Ptn = 0x053F;
  1203.   sp->Pri = 3;
  1204.   sp++;
  1205.  
  1206.   ScoreDisp();
  1207.   DispSprite();
  1208.  
  1209.  
  1210.   if (!BgmFlag) {
  1211.     for (i=0;i<30;i++) {
  1212.        WaitVDisp();
  1213.     }
  1214.     BgmFlag = 1;
  1215.   }
  1216.  
  1217.  
  1218.   if (CursorY == 208 || CursorY == 224) {
  1219.     if (!PushAFlag) {
  1220.       if (((KeyPort&0x40)==0) || ((KeyPort&0x20)==0)) {
  1221.         GameStatus    = 1;
  1222.         /*GameStage   = 1;*/
  1223.         BgmFlag       = 0;
  1224.         MyLeft        = 2;
  1225.         Score         = 0;
  1226.         ExtendEvery   = 10000;
  1227.         EnemyCnt      = 0;
  1228.         MazeCnt       = 0;
  1229.         EnemyDownRate = 260;
  1230.       
  1231.         if (CursorY == 224) {
  1232.           ContinueMazeCnt = MazeCnt;
  1233.           ContinueCnt     = 3;
  1234.           GameStage       = 1;
  1235.         }
  1236.         if (CursorY == 208) {
  1237.           MazeCnt         = ContinueMazeCnt;
  1238.           ContinueMazeCnt = MazeCnt;
  1239.           ContinueCnt -= 1;
  1240.         }
  1241.     
  1242.         MazeDisp();
  1243.       }
  1244.     }
  1245.   }
  1246.   
  1247.   
  1248.   
  1249.   if (CursorY == 240) {
  1250.     if (!PushAFlag) {
  1251.       if (((KeyPort&0x40)==0) || ((KeyPort&0x20)==0)) {
  1252.         return -1;
  1253.       }
  1254.     }
  1255.   }
  1256.  
  1257.   return 0;
  1258.  
  1259. }
  1260.  
  1261. static void
  1262. GameOver(int Y)
  1263. {
  1264.   short i;
  1265.  
  1266.   for (i=0;i<5;i++) {
  1267.     sp->X   = 104+(i*16);
  1268.     sp->Y   = Y;
  1269.     sp->Ptn = 0x0486+i;
  1270.     sp->Pri = 3;
  1271.     sp++;
  1272.   }
  1273.  
  1274. }
  1275.  
  1276. static void
  1277. MazeDisp(void)
  1278. {
  1279.   short i,j;
  1280.   char  LoopFlag;
  1281.  
  1282.   for (i=0;i<15;i++) {
  1283.     for (j=0;j<15;j++) {
  1284.        LoopFlag=0;
  1285.        
  1286.        while (!LoopFlag) {
  1287.          switch (MazePtr[MazeCnt]) {
  1288.            case  0x21: {
  1289.               
  1290.               AllClear();  /* All Stage Clear */
  1291.               /*
  1292.               Term();
  1293.               */
  1294.               MazeCnt   = 0;
  1295.               GameStage = 1;
  1296.               if (EnemyDownRate > 200) EnemyDownRate -= 20;
  1297.               break;
  1298.            }
  1299.            case  0x30: {
  1300.               TileDraw(i,j);
  1301.               LoopFlag = -1;
  1302.               MazeCnt++;
  1303.               break;
  1304.            }
  1305.            case  0x31: {
  1306.               BlockDraw(i,j);
  1307.               LoopFlag = -1;
  1308.               MazeCnt++;
  1309.               break;
  1310.            }
  1311.            case  0x4d: {
  1312.               if (!CreateEnemy(i,j,0)) {
  1313.                 printf("ôGâLâââëé╠âüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1314.                 Term(); /* Abort */
  1315.               }
  1316.               TileDraw(i,j);
  1317.               LoopFlag = -1;
  1318.               MazeCnt++;
  1319.               break;
  1320.            }
  1321.            case  0x4e: {
  1322.               if (!CreateEnemy(i,j,1)) {
  1323.                 printf("ôGâLâââëé╠âüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1324.                 Term(); /* Abort */
  1325.               }
  1326.               TileDraw(i,j);
  1327.               LoopFlag = -1;
  1328.               MazeCnt++;
  1329.               break;
  1330.            }
  1331.            case  0x47: {
  1332.               if (!CreateGate(i,j)) {
  1333.                 printf("âQü[âgé╠âüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1334.                 Term(); /* Abort */
  1335.               }
  1336.               TileDraw(i,j);
  1337.               LoopFlag = -1;
  1338.               MazeCnt++;
  1339.               break;
  1340.            }
  1341.             case  0x52: {
  1342.               TileDraw(i,j);
  1343.               My->X      = j*16+16+8;
  1344.               My->Y      = i*16+16+8;
  1345.               My->InitX  = j*16+16+8;
  1346.               My->InitY  = i*16+16+8;
  1347.               My->Houkou = 0;
  1348.               My->Cnt    = 0;
  1349.               LoopFlag = -1;
  1350.               MazeCnt++;
  1351.               break;
  1352.            }
  1353.            default:
  1354.              if ((0x80 <= MazePtr[MazeCnt] && MazePtr[MazeCnt] <= 0x9F)
  1355.               || (0xE0 <= MazePtr[MazeCnt] && MazePtr[MazeCnt] <= 0xFE)) {
  1356.                MazeCnt+=2;
  1357.              } else {
  1358.                MazeCnt++;
  1359.              }
  1360.          }
  1361.        }
  1362.     }
  1363.   }
  1364. }
  1365.  
  1366.  
  1367. static void
  1368. BlockDraw(short i,short j)
  1369. {
  1370.    short *Addr ;
  1371.  
  1372.    (short *)Addr = 0xEBE000+128;
  1373.  
  1374.    (short *)Addr += (i*2) * 64 + (j*2) + 1;
  1375.  
  1376.    *(short *)Addr      = 0x0204;
  1377.    *(short *)(Addr+1)  = 0x0206;
  1378.    *(short *)(Addr+64) = 0x0205;
  1379.    *(short *)(Addr+65) = 0x0207;
  1380. }
  1381. static void
  1382. TileDraw(short i,short j)
  1383. {
  1384.    short *Addr ;
  1385.  
  1386.    (short *)Addr = 0xEBE000+128;
  1387.  
  1388.    (short *)Addr += (i*2) * 64 + (j*2) + 1;
  1389.  
  1390.    *(short *)Addr      = 0x0208;
  1391.    *(short *)(Addr+1)  = 0x020A;
  1392.    *(short *)(Addr+64) = 0x0209;
  1393.    *(short *)(Addr+65) = 0x020B;
  1394.  
  1395. }
  1396. static char
  1397. MyInit(void)
  1398. {
  1399.   (_MyChr *)My = (_MyChr *)malloc(sizeof(_MyChr));
  1400.   if (My == NULL)  return 0;
  1401.   return -1;
  1402. }
  1403.  
  1404. static void
  1405. MyChrMove()
  1406. {
  1407.   unsigned short *Addr;
  1408.   unsigned short Ptn;
  1409.   unsigned char  OldHoukou;
  1410.  
  1411.   unsigned char KeyPort = GetKeyPort();
  1412.  
  1413.   OldHoukou=My->Houkou;
  1414.  
  1415.  
  1416.   if ( (((My->X-24) % 16) == 0) 
  1417.     && ( ((My->Y-24) % 16) == 0) ) {
  1418.  
  1419.      My->UpFlag    = 0;
  1420.      My->DownFlag  = 0;
  1421.      My->LeftFlag  = 0;
  1422.      My->RightFlag = 0;
  1423.      My->Houkou    = 0;
  1424.  
  1425.      (unsigned short *)Addr = (unsigned short *)0xEBE002+((My->Y-24)/8)*64+((My->X-24)/8)+64;
  1426.  
  1427.      if (*(short *)(Addr-64)  > 0x0207 && *(short *)(Addr-63) > 0x0207) My->UpFlag     = 1;
  1428.      if (*(short *)(Addr+128) > 0x0207 && *(short *)(Addr+129)> 0x0207) My->DownFlag   = 1;
  1429.      if (*(short *)(Addr-1)   > 0x0207 && *(short *)(Addr+63) > 0x0207) My->LeftFlag   = 1;
  1430.      if (*(short *)(Addr+2)   > 0x0207 && *(short *)(Addr+66) > 0x0207) My->RightFlag  = 1;
  1431.   }
  1432.  
  1433.   if (((My->X-8) % 16) == 0) {
  1434.     if (OldHoukou > 2) {
  1435.       if ( ((KeyPort & 0x01) == 0) && (My->UpFlag    == 1) ) My->Houkou = 1;
  1436.       if ( ((KeyPort & 0x02) == 0) && (My->DownFlag  == 1) ) My->Houkou = 2;
  1437.     }
  1438.   }
  1439.   if (((My->Y-8) % 16) == 0) {
  1440.     if (OldHoukou < 3) {
  1441.       if ( ((KeyPort & 0x04) == 0) && (My->LeftFlag  == 1) ) My->Houkou = 3;
  1442.       if ( ((KeyPort & 0x08) == 0) && (My->RightFlag == 1) ) My->Houkou = 4;
  1443.     }
  1444.   }
  1445.  
  1446.   if (My->Houkou == 1 || !My->Houkou) {
  1447.     if (((My->X-8) % 16) == 0) {
  1448.       if ( ((KeyPort & 0x02) == 0) && (My->DownFlag  == 1) ) My->Houkou = 2;
  1449.     }
  1450.   }
  1451.   if (My->Houkou == 2 || !My->Houkou) {
  1452.     if (((My->X-8) % 16) == 0) {
  1453.       if ( ((KeyPort & 0x01) == 0) && (My->UpFlag  == 1) ) My->Houkou = 1;
  1454.     }
  1455.   }
  1456.   if (My->Houkou == 3 || !My->Houkou) {
  1457.     if (((My->Y-8) % 16) == 0) {
  1458.       if ( ((KeyPort & 0x08) == 0) && (My->RightFlag  == 1) ) My->Houkou = 4;
  1459.     }
  1460.   }
  1461.   if (My->Houkou == 4 || !My->Houkou) {
  1462.     if (((My->Y-8) % 16) == 0) {
  1463.       if ( ((KeyPort & 0x04) == 0) && (My->LeftFlag  == 1) ) My->Houkou = 3;
  1464.     }
  1465.   }
  1466.  
  1467.   if (My->Houkou == 1) My->Y--;
  1468.   if (My->Houkou == 2) My->Y++;
  1469.   if (My->Houkou == 3) My->X--;
  1470.   if (My->Houkou == 4) My->X++;
  1471.  
  1472.   My->Cnt++;
  1473.   if (My->Cnt == 28)  My->Cnt = 0;
  1474.  
  1475.   if (My->Houkou == 1)  Ptn=0x0120+(My->Cnt/4);
  1476.   if (My->Houkou == 2)  Ptn=0x0140+(My->Cnt/4);
  1477.   if (My->Houkou == 3)  Ptn=0x0160+(My->Cnt/4);
  1478.   if (My->Houkou == 4)  Ptn=0x0147+(My->Cnt/4);
  1479.  
  1480.   if (!My->Houkou)  Ptn=0x0127+(My->Cnt/14);
  1481.  
  1482.   sp->X   = My->X;
  1483.   sp->Y   = My->Y;
  1484.   sp->Ptn = Ptn+0x10;
  1485.   sp->Pri = 3;
  1486.   sp++;
  1487.   sp->X   = My->X;
  1488.   sp->Y   = My->Y-16;
  1489.   sp->Ptn = Ptn;
  1490.   sp->Pri = 3;
  1491.   sp++;
  1492.   
  1493. }
  1494.  
  1495. static void
  1496. DispSprite()
  1497. {
  1498.    volatile char *Reg;
  1499.    int           i;
  1500.    _Sprite       *Addr;
  1501.  
  1502.     short            *PalAddr;
  1503.     short            Table[3] = {0x0026,0x0030,0x403e};
  1504.     unsigned char    SetWork;
  1505.  
  1506.     AnimeCnt++;
  1507.     if (AnimeCnt == 18) AnimeCnt=0;
  1508.     SetWork = AnimeCnt / 6;
  1509.     (short *)PalAddr = 0x0e82244;
  1510.  
  1511.   (char *)Reg = 0xE88001;
  1512.   while (!(*Reg & 0x10));
  1513.   while ( (*Reg & 0x10));
  1514.  
  1515.     for (i=0;i<3;i++) {
  1516.         *(short *)PalAddr = Table[SetWork];
  1517.         PalAddr++;
  1518.         SetWork++;
  1519.         if (SetWork == 3) SetWork = 0;
  1520.     }
  1521.  
  1522.   (_Sprite *)Addr = 0xEB0000;
  1523.   (_Sprite *)sp   = (_Sprite *)Sprite;
  1524.  
  1525.   for (i=0;i<128;i++) {
  1526.     *(_Sprite *)Addr++  = *(_Sprite *)sp++;
  1527.   }
  1528. }
  1529.  
  1530.  
  1531. static void
  1532. WaitVDisp(void)
  1533. {
  1534.    volatile char *Reg;
  1535.  
  1536.   (char *)Reg = 0xE88001;
  1537.   while (!(*Reg & 0x10));
  1538.   while ( (*Reg & 0x10));
  1539. }
  1540.  
  1541.  
  1542. static char
  1543. MazeLoad(void)
  1544. {
  1545.   FILE *FilePtr;
  1546.   int Size;
  1547.  
  1548.   FilePtr = fopen("MazeData.Dat","rt");
  1549.  
  1550.   if (FilePtr != NULL) {
  1551.      Size = filelength(fileno(FilePtr));
  1552.      if (((unsigned char *)MazePtr=(unsigned char *)malloc(Size)) == NULL) {
  1553.         printf("â}âbâvüEâfü[â^é╠âüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1554.         fclose(FilePtr);
  1555.         return 0;
  1556.      } else {
  1557.         fread(MazePtr,1,filelength(fileno(FilePtr)),FilePtr);
  1558.         fclose(FilePtr);
  1559.         return -1;
  1560.      }
  1561.   } else {
  1562.     printf("â}âbâvüEâfü[â^é╠ô╟é▌ì₧é▌é╔Ä╕ösé╡é▄é╡é╜üB\n");
  1563.     return 0;
  1564.   }
  1565. }
  1566.  
  1567. static char
  1568. CreateEnemy(short i, short j,char Type)
  1569. {
  1570.   _Enemy  *Enemy;
  1571.  
  1572.   if  ( ((_Enemy *)Enemy=(_Enemy *)malloc(sizeof(_Enemy))) == NULL ) return 0;
  1573.  
  1574.   Enemy->Next        = Start->Next;
  1575.   Enemy->Prev        = Start;
  1576.   Enemy->Prev->Next  = Enemy;
  1577.   Enemy->Next->Prev  = Enemy;
  1578.  
  1579.   Enemy->X       = j*16+16+8;
  1580.   Enemy->Y       = i*16+16+8;
  1581.   Enemy->InitX   = j*16+16+8;
  1582.   Enemy->InitY   = i*16+16+8;
  1583.   Enemy->Type    = Type;
  1584.   Enemy->Houkou  = 0;
  1585.   Enemy->Cnt     = 0;
  1586.   Enemy->DownCnt = 0;
  1587.  
  1588.   EnemyCnt ++;
  1589.  
  1590.   return -1;
  1591. }
  1592.  
  1593. static char
  1594. EnemyInit(void)
  1595. {
  1596.   if  ( ((_Enemy *)Start=(_Enemy *)malloc(sizeof(_Enemy))) == NULL ) {
  1597.       printf("ôGâLâââëérésé`éqésâüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1598.       return 0;
  1599.   }
  1600.   if  ( ((_Enemy *)End=(_Enemy *)malloc(sizeof(_Enemy))) == NULL ) { 
  1601.       printf("ôGâLâââëédémécâüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1602.       return 0;
  1603.   }
  1604.   
  1605.   Start->Prev = NULL;
  1606.   Start->Next = End;
  1607.   End->Prev   = Start;
  1608.   End->Next   = NULL;
  1609.  
  1610.   return -1;
  1611. }
  1612.  
  1613. static char
  1614. GateInit(void)
  1615. {
  1616.   if  ( ((_Gate *)GateStart=(_Gate *)malloc(sizeof(_Gate))) == NULL ) {
  1617.       printf("âQü[âgérésé`éqésâüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1618.       return 0;
  1619.   }
  1620.   if  ( ((_Gate *)GateEnd=(_Gate *)malloc(sizeof(_Gate))) == NULL ) { 
  1621.       printf("âQü[âgédémécâüâéâèé╠èmò█é╔Ä╕ösé╡é▄é╡é╜\n");
  1622.       return 0;
  1623.   }
  1624.   
  1625.   GateStart->Prev = NULL;
  1626.   GateStart->Next = GateEnd;
  1627.   GateEnd->Prev   = GateStart;
  1628.   GateEnd->Next   = NULL;
  1629.  
  1630.   return -1;
  1631. }
  1632.  
  1633. static void
  1634. EnemyMain(void)
  1635. {
  1636.   _Enemy  *Enemy;
  1637.  
  1638.   EnemyDownFlag = 0;
  1639.  
  1640.   Enemy = Start->Next;
  1641.  
  1642.   while ( Enemy->Next != NULL ) {
  1643.  
  1644.     if (!Enemy->DownCnt) {
  1645.       if ( !Enemy->Type )  {
  1646.         EnemyOikake1(Enemy);
  1647.       } else {
  1648.         EnemyOikake2(Enemy);
  1649.       }
  1650.       if ((My->X < (Enemy->X+8)) && ((My->X+8) > Enemy->X)
  1651.        && (My->Y < (Enemy->Y+8)) && ((My->Y+8) > Enemy->Y))  GameStatus = 6;
  1652.     } else {
  1653.       Enemy->DownCnt--;
  1654.       if (!Enemy->DownCnt) {
  1655.          if (!PcmFlag) { 
  1656.            Se(4);
  1657.            PcmFlag  = -1;
  1658.          }
  1659.          Enemy->Cnt = 0;
  1660.       }
  1661.       Enemy->Cnt++;
  1662.       if (Enemy->Cnt < 16) {
  1663.           sp->X   = Enemy->X;
  1664.           sp->Y   = Enemy->Y;
  1665.           if (!Enemy->Type) {
  1666.               sp->Ptn = 0x068b+(Enemy->Cnt/4);
  1667.           } else {
  1668.               sp->Ptn = 0x078b+(Enemy->Cnt/4);
  1669.           }
  1670.           sp->Pri = 3;
  1671.           sp++;
  1672.       } else {
  1673.           if (Enemy->DownCnt < 16) {
  1674.               sp->X   = Enemy->X;
  1675.               sp->Y   = Enemy->Y;
  1676.               if (!Enemy->Type) {
  1677.                   sp->Ptn = 0x068b+(Enemy->DownCnt/4);
  1678.               } else {
  1679.                   sp->Ptn = 0x078b+(Enemy->DownCnt/4);
  1680.               }
  1681.               sp->Pri = 3;
  1682.               sp++;
  1683.           } else {
  1684.               if (Enemy->Cnt == 32) Enemy->Cnt = 16;
  1685.               sp->X   = Enemy->X;
  1686.               sp->Y   = Enemy->Y-8;
  1687.               sp->Ptn = 0x0310+((Enemy->Cnt-16)/7);
  1688.               sp->Pri = 3;
  1689.               sp++;
  1690.           }
  1691.       }
  1692.     }
  1693.     Enemy = Enemy->Next;
  1694.   }
  1695. }
  1696.  
  1697. static void
  1698. EnemyOikake1(_Enemy *Enemy)
  1699. {
  1700.   char UpFlag    = 0;
  1701.   char DownFlag  = 0;
  1702.   char LeftFlag  = 0;
  1703.   char RightFlag = 0;
  1704.   char OldHoukou = Enemy->Houkou;
  1705.   char MoveCnt   = 0;
  1706.   short *Addr;
  1707.  
  1708.   short Ptn=0x0677;
  1709.  
  1710.  _Gate *Gate;
  1711.  
  1712.   Enemy->Cnt ++;
  1713.   if (Enemy->Cnt == 28) Enemy->Cnt = 0;
  1714.   if (!(Enemy->Cnt%2) && (GameStatus == 1)) {
  1715.  
  1716.     if ( (((Enemy->X-24) % 16) == 0) && ( ((Enemy->Y-24) % 16) == 0) ) {
  1717.        (unsigned short *)Addr = (unsigned short *)0xEBE002+((Enemy->Y-24)/8)*64+((Enemy->X-24)/8)+64;
  1718.        Enemy->Houkou = 0;
  1719.        if (*(short *)(Addr-64)  > 0x0207 && *(short *)(Addr-63) > 0x0207) {
  1720.          UpFlag     = 1;
  1721.          MoveCnt++;
  1722.        } 
  1723.        if (*(short *)(Addr+128) > 0x0207 && *(short *)(Addr+129)> 0x0207) {
  1724.          DownFlag   = 1;
  1725.          MoveCnt++;
  1726.        }
  1727.        if (*(short *)(Addr-1)   > 0x0207 && *(short *)(Addr+63) > 0x0207) {
  1728.          LeftFlag   = 1;
  1729.          MoveCnt++;
  1730.        }
  1731.        if (*(short *)(Addr+2)   > 0x0207 && *(short *)(Addr+66) > 0x0207) {
  1732.          RightFlag  = 1;
  1733.          MoveCnt++;
  1734.        }
  1735.        if (MoveCnt > 1) {
  1736.          if (OldHoukou == 3 || OldHoukou == 4 || !OldHoukou) {
  1737.            if ((UpFlag     == 1) && (My->Y < Enemy->Y))  Enemy->Houkou = 1;
  1738.            if ((DownFlag   == 1) && (My->Y > Enemy->Y))  Enemy->Houkou = 2;
  1739.          }
  1740.  
  1741.          if (OldHoukou == 1 || OldHoukou == 2 || !OldHoukou) {
  1742.            if ((LeftFlag   == 1) && (My->X < Enemy->X))  Enemy->Houkou = 3;
  1743.            if ((RightFlag  == 1) && (My->X > Enemy->X))  Enemy->Houkou = 4;
  1744.          }
  1745.          if (!Enemy->Houkou) {
  1746.            if (OldHoukou == 1  && UpFlag)    Enemy->Houkou = 1;
  1747.            if (OldHoukou == 2  && DownFlag)  Enemy->Houkou = 2;
  1748.            if (OldHoukou == 3  && LeftFlag)  Enemy->Houkou = 3;
  1749.            if (OldHoukou == 4  && RightFlag) Enemy->Houkou = 4;
  1750.          }
  1751.          if (!Enemy->Houkou) {
  1752.            if (OldHoukou == 1  && RightFlag)  Enemy->Houkou = 4;
  1753.            if (OldHoukou == 4  && DownFlag)   Enemy->Houkou = 2;
  1754.            if (OldHoukou == 2  && LeftFlag)   Enemy->Houkou = 3;
  1755.            if (OldHoukou == 3  && UpFlag)     Enemy->Houkou = 1;
  1756.          }
  1757.          if (!Enemy->Houkou) {
  1758.            if (RightFlag)                    Enemy->Houkou = 4;
  1759.            if (!Enemy->Houkou && DownFlag)   Enemy->Houkou = 2;
  1760.            if (!Enemy->Houkou && LeftFlag)   Enemy->Houkou = 3;
  1761.            if (!Enemy->Houkou && UpFlag)     Enemy->Houkou = 1;
  1762.          }
  1763.        } else {
  1764.          if (OldHoukou == 1 || (!Enemy->Houkou && DownFlag))  Enemy->Houkou = 2;
  1765.          if (OldHoukou == 2 || (!Enemy->Houkou && UpFlag))    Enemy->Houkou = 1;
  1766.          if (OldHoukou == 3 || (!Enemy->Houkou && RightFlag)) Enemy->Houkou = 4;
  1767.          if (OldHoukou == 4 || (!Enemy->Houkou && LeftFlag))  Enemy->Houkou = 3;
  1768.        }
  1769.     }
  1770.  
  1771.     if (Enemy->Houkou == 1) Enemy->Y -= 1;
  1772.     if (Enemy->Houkou == 2) Enemy->Y += 1;
  1773.     if (Enemy->Houkou == 3) Enemy->X -= 1;
  1774.     if (Enemy->Houkou == 4) Enemy->X += 1;
  1775.  
  1776.     Gate     = GateStart->Next;
  1777.     while (Gate->Next != NULL) {
  1778.       if (Gate->X == Enemy->X && Gate->Y == Enemy->Y && Gate->OpenFlag == 2) {
  1779.         if (!EnemyDownFlag) {
  1780.           Se(3);
  1781.           EnemyDownFlag = -1;
  1782.         }
  1783.         Enemy->Cnt     = 0;
  1784.         Enemy->DownCnt = EnemyDownRate;
  1785.         break;
  1786.       }
  1787.       Gate=Gate->Next;
  1788.     }
  1789.   }
  1790.  
  1791.   if (Enemy->Houkou == 1) Ptn=0x067B;
  1792.   if (Enemy->Houkou == 2) Ptn=0x0677;
  1793.   if (Enemy->Houkou == 3) Ptn=0x0667;
  1794.   if (Enemy->Houkou == 4) Ptn=0x066B;
  1795.  
  1796.   sp->X   = Enemy->X;
  1797.   sp->Y   = Enemy->Y;
  1798.   sp->Ptn = Ptn+((Enemy->Cnt/7));
  1799.   sp->Pri = 3;
  1800.   sp++;
  1801. }
  1802. static void
  1803. EnemyOikake2(_Enemy *Enemy)
  1804. {
  1805.   char UpFlag    = 0;
  1806.   char DownFlag  = 0;
  1807.   char LeftFlag  = 0;
  1808.   char RightFlag = 0;
  1809.   char OldHoukou = Enemy->Houkou;
  1810.   char MoveCnt   = 0;
  1811.   short *Addr;
  1812.  
  1813.   short Ptn=0x0777;
  1814.  
  1815.   _Gate  *Gate;
  1816.  
  1817.   Enemy->Cnt ++;
  1818.   if (Enemy->Cnt == 28) Enemy->Cnt = 0;
  1819.   if (!(Enemy->Cnt%2) && (GameStatus == 1)) {
  1820.  
  1821.     if ( (((Enemy->X-8) % 16) == 0) && ( ((Enemy->Y-8) % 16) == 0) ) {
  1822.        (unsigned short *)Addr = (unsigned short *)0xEBE002+((Enemy->Y-24)/8)*64+((Enemy->X-24)/8)+64;
  1823.        Enemy->Houkou = 0;
  1824.        if (*(short *)(Addr-64)  > 0x0207 && *(short *)(Addr-63) > 0x0207) {
  1825.          UpFlag     = 1;
  1826.          MoveCnt++;
  1827.        } 
  1828.        if (*(short *)(Addr+128) > 0x0207 && *(short *)(Addr+129)> 0x0207) {
  1829.          DownFlag   = 1;
  1830.          MoveCnt++;
  1831.        }
  1832.        if (*(short *)(Addr-1)   > 0x0207 && *(short *)(Addr+63) > 0x0207) {
  1833.          LeftFlag   = 1;
  1834.          MoveCnt++;
  1835.        }
  1836.        if (*(short *)(Addr+2)   > 0x0207 && *(short *)(Addr+66) > 0x0207) {
  1837.          RightFlag  = 1;
  1838.          MoveCnt++;
  1839.        }
  1840.        if (MoveCnt > 1) {
  1841.          if (OldHoukou == 3 || OldHoukou == 4 || !OldHoukou) {
  1842.            if ((UpFlag     == 1) && (My->Y < Enemy->Y))  Enemy->Houkou = 1;
  1843.            if ((DownFlag   == 1) && (My->Y > Enemy->Y))  Enemy->Houkou = 2;
  1844.          }
  1845.  
  1846.          if (OldHoukou == 1 || OldHoukou == 2 || !OldHoukou) {
  1847.            if ((LeftFlag   == 1) && (My->X < Enemy->X))  Enemy->Houkou = 3;
  1848.            if ((RightFlag  == 1) && (My->X > Enemy->X))  Enemy->Houkou = 4;
  1849.          }
  1850.          if (!Enemy->Houkou) {
  1851.            if (OldHoukou == 1  && UpFlag)     Enemy->Houkou = 1;
  1852.            if (OldHoukou == 2  && DownFlag)   Enemy->Houkou = 2;
  1853.            if (OldHoukou == 3  && LeftFlag)   Enemy->Houkou = 3;
  1854.            if (OldHoukou == 4  && RightFlag)  Enemy->Houkou = 4;
  1855.          }
  1856.          if (!Enemy->Houkou) {
  1857.            if (OldHoukou == 1  && LeftFlag)   Enemy->Houkou = 3;
  1858.            if (OldHoukou == 3  && DownFlag)   Enemy->Houkou = 2;
  1859.            if (OldHoukou == 2  && RightFlag)  Enemy->Houkou = 4;
  1860.            if (OldHoukou == 4  && UpFlag)     Enemy->Houkou = 1;
  1861.          }
  1862.          if (!Enemy->Houkou) {
  1863.            if (LeftFlag)                      Enemy->Houkou = 3;
  1864.            if (!Enemy->Houkou && DownFlag)    Enemy->Houkou = 2;
  1865.            if (!Enemy->Houkou && RightFlag)   Enemy->Houkou = 4;
  1866.            if (!Enemy->Houkou && UpFlag)      Enemy->Houkou = 1;
  1867.          }
  1868.        } else {
  1869.          if (OldHoukou == 1 || (!Enemy->Houkou && DownFlag))  Enemy->Houkou = 2;
  1870.          if (OldHoukou == 2 || (!Enemy->Houkou && UpFlag))    Enemy->Houkou = 1;
  1871.          if (OldHoukou == 3 || (!Enemy->Houkou && RightFlag)) Enemy->Houkou = 4;
  1872.          if (OldHoukou == 4 || (!Enemy->Houkou && LeftFlag))  Enemy->Houkou = 3;
  1873.        }
  1874.     }
  1875.  
  1876.     if (Enemy->Houkou == 1) Enemy->Y -= 1;
  1877.     if (Enemy->Houkou == 2) Enemy->Y += 1;
  1878.     if (Enemy->Houkou == 3) Enemy->X -= 1;
  1879.     if (Enemy->Houkou == 4) Enemy->X += 1;
  1880.  
  1881.     Gate     = GateStart->Next;
  1882.     while (Gate->Next != NULL) {
  1883.       if (Gate->X == Enemy->X && Gate->Y == Enemy->Y && Gate->OpenFlag == 2) {
  1884.         if (!EnemyDownFlag) {
  1885.           Se(3);
  1886.           EnemyDownFlag = -1;
  1887.         }
  1888.         Enemy->Cnt     = 0;
  1889.         Enemy->DownCnt = EnemyDownRate;
  1890.         break;
  1891.       }
  1892.       Gate=Gate->Next;
  1893.     }
  1894.   }
  1895.  
  1896.   if (Enemy->Houkou == 1) Ptn=0x077B;
  1897.   if (Enemy->Houkou == 2) Ptn=0x0777;
  1898.   if (Enemy->Houkou == 3) Ptn=0x0767;
  1899.   if (Enemy->Houkou == 4) Ptn=0x076B;
  1900.  
  1901.   sp->X   = Enemy->X;
  1902.   sp->Y   = Enemy->Y;
  1903.   sp->Ptn = Ptn+(Enemy->Cnt/7);
  1904.   sp->Pri = 3;
  1905.   sp++;
  1906. }
  1907.  
  1908. static char
  1909. CreateGate(short i,short j)
  1910. {
  1911.   _Gate  *Gate;
  1912.  
  1913.   if  ( ((_Gate *)Gate=(_Gate *)malloc(sizeof(_Gate))) == NULL ) return 0;
  1914.  
  1915.   Gate->Next        = GateStart->Next;
  1916.   Gate->Prev        = GateStart;
  1917.   Gate->Prev->Next  = Gate;
  1918.   Gate->Next->Prev  = Gate;
  1919.  
  1920.   Gate->X        = j*16+16+8;
  1921.   Gate->Y        = i*16+16+8;
  1922.   Gate->Status   = 5;
  1923.   Gate->OpenFlag = 0;
  1924.   Gate->AnimeCnt = 255;
  1925.  
  1926.   return -1;
  1927. }
  1928.  
  1929. static void
  1930. Gate(void)
  1931. {
  1932.   _Gate  *Gate; 
  1933.   short  Ptn;
  1934.   _Enemy *Enemy,*Dummy;
  1935.  
  1936.   unsigned  int Cnt;
  1937.  
  1938.   _Sprite *GateSp;
  1939.  
  1940.   short                AddTblX[8]  = { 0,  1,2,1,0,-1,-2,-1};
  1941.   short                AddTblY[8]  = {-2, -1,0,1,2, 1, 0,-1};
  1942.   unsigned short    StarTbl[4]  = {0x034e,0x034f,0x035e,0x035f};
  1943.   int            i;
  1944.  
  1945.   (_Sprite *)GateSp = &Sprite[127];
  1946.  
  1947.   Gate = GateStart->Next;
  1948.  
  1949.   while ( Gate->Next != NULL ) {
  1950.  
  1951.     if (Gate->AnimeCnt < 32) {
  1952.       for (i=0;i<8;i++) {
  1953.         sp->X   = Gate->X+(AddTblX[i] * Gate->AnimeCnt);
  1954.         sp->Y   = Gate->Y+(AddTblY[i] * Gate->AnimeCnt);
  1955.         sp->Ptn = StarTbl[Gate->AnimeCnt/8];
  1956.         sp->Pri = 3;
  1957.         sp++;
  1958.       }
  1959.       Gate->AnimeCnt ++;
  1960.     }
  1961.  
  1962. /* GateOpen */
  1963.     if (!Gate->OpenFlag) {
  1964.       if (Gate->Y == My->Y && (Gate->X < (My->X+16) && My->X < (Gate->X+16))) {
  1965.         Gate->Status = (Gate->X - My->X)/3;
  1966.         if (Gate->Status<0) Gate->Status *= -1;
  1967.       }
  1968.       if (Gate->X == My->X && (Gate->Y < (My->Y+16) && My->Y < (Gate->Y+16))) {
  1969.         Gate->Status = (Gate->Y - My->Y)/3;
  1970.         if (Gate->Status<0) Gate->Status *= -1;
  1971.       }
  1972.       if (Gate->X == My->X && Gate->Y == My->Y) { 
  1973.          Gate->OpenFlag = 1;
  1974.          Se(0);
  1975.       }
  1976.     }
  1977.  
  1978.     if (Gate->OpenFlag == 1) {
  1979.        if (Gate->X+15 < My->X) Gate->OpenFlag = 2;
  1980.        if (Gate->X-15 > My->X) Gate->OpenFlag = 2;
  1981.        if (Gate->Y+15 < My->Y) Gate->OpenFlag = 2;
  1982.        if (Gate->Y-15 > My->Y) Gate->OpenFlag = 2;
  1983.     }
  1984.  
  1985.     if (Gate->OpenFlag == 2) {
  1986.       if (Gate->Y == My->Y && (Gate->X < (My->X+16) && My->X < (Gate->X+16))) {
  1987.         Gate->Status = (Gate->X - My->X)/3;
  1988.         if (Gate->Status<0) Gate->Status *= -1;
  1989.         Gate->Status = 5 - Gate->Status;
  1990.       }
  1991.       if (Gate->X == My->X && (Gate->Y < (My->Y+16) && My->Y < (Gate->Y+16))) {
  1992.         Gate->Status = (Gate->Y - My->Y)/3;
  1993.         if (Gate->Status<0) Gate->Status *= -1;
  1994.         Gate->Status = 5 - Gate->Status;
  1995.       }
  1996.       if (Gate->X == My->X && Gate->Y == My->Y) {
  1997.          Gate->OpenFlag = 3;
  1998.          Se(1);
  1999.       }
  2000.     } 
  2001.  
  2002.     if (Gate->OpenFlag == 3) {
  2003.        Cnt=1;
  2004.        Enemy = Start->Next;
  2005.        while (Enemy->Next != NULL) {
  2006.          if (Gate->X == Enemy->X && Gate->Y == Enemy->Y && Enemy->DownCnt) {
  2007. /*         if (!PcmFlag) {
  2008.              Se(2);
  2009.              PcmFlag = -1;
  2010.            }
  2011. */
  2012.            Dummy = Enemy;
  2013.            Enemy->Prev->Next = Enemy->Next;
  2014.            Enemy->Next->Prev = Enemy->Prev;
  2015.            Enemy = Enemy->Next;
  2016.            free(Dummy);
  2017.            Gate->OpenFlag = 4;
  2018.            EnemyCnt--;
  2019.  
  2020.            Gate->AnimeCnt = 0;
  2021.  
  2022.            
  2023.            if (!EnemyCnt) { 
  2024.              Bgm(4);
  2025.              PcmFlag = -1;
  2026.            } else {
  2027.              if (!PcmFlag) {
  2028.                 Se(2);
  2029.                 PcmFlag = -1;
  2030.                 GateCloseCnt ++;
  2031.                 if (GateCloseCnt == 2) TargetTimer=0;
  2032.              }
  2033.            }
  2034.  
  2035.            Score      +=(Cnt*100);
  2036.            StageScore +=(Cnt*100);
  2037.            Cnt++;
  2038.          } else {
  2039.            Enemy = Enemy->Next;
  2040.          }
  2041.        }
  2042.        if (Gate->X+15 < My->X) Gate->OpenFlag = 0;
  2043.        if (Gate->X-15 > My->X) Gate->OpenFlag = 0;
  2044.        if (Gate->Y+15 < My->Y) Gate->OpenFlag = 0;
  2045.        if (Gate->Y-15 > My->Y) Gate->OpenFlag = 0;
  2046.     }
  2047.  
  2048.     if (Gate->OpenFlag != 4) {
  2049.        Ptn = 0x0208-Gate->Status;
  2050.     } else {
  2051.        Ptn = 0x0209;
  2052.     }
  2053.  
  2054.  
  2055.     GateSp->X   = Gate->X;
  2056.     GateSp->Y   = Gate->Y;
  2057.     GateSp->Ptn = Ptn;
  2058.     GateSp->Pri = 3;
  2059.     GateSp--;
  2060.  
  2061.     Gate = Gate->Next;
  2062.   }
  2063. }
  2064.  
  2065. static char
  2066. BgmRead(void)
  2067. {
  2068.   FILE *FilePtr;
  2069.   unsigned char Str[256];
  2070.   char          *From;
  2071.   char          *To;
  2072.   unsigned char i;
  2073.   unsigned char j;
  2074.   char          *Addr;
  2075.   unsigned char BgmCnt=0;
  2076.   unsigned char BgmFile[128][32];
  2077.  
  2078.  
  2079.   FilePtr = fopen("Bgm.dat","rt");
  2080.  
  2081.   if (FilePtr != NULL) {
  2082.     i=0;
  2083.     while (!feof(FilePtr)) {
  2084.       fgets(Str,256,FilePtr);      /* 1 line read */
  2085.         From=strrchr(Str,'<');
  2086.         To  =strrchr(Str,'>');
  2087.         if (From != NULL && To != NULL) {
  2088.           j=0;
  2089.           for (Addr=From+1;Addr<=To-1;Addr++) {
  2090.             BgmFile[i][j]=*(char *)Addr;
  2091.             j++;
  2092.           }
  2093.           BgmFile[i][j] = 0;  /* end code insert */ 
  2094.           BgmFile[i][j+1] = 0;  /* end code insert */ 
  2095.           i++;
  2096.           BgmCnt++;
  2097.         }
  2098.     }
  2099.     fclose (FilePtr);
  2100.   } else {
  2101.     printf("éaéfélÆΦï`üiBgm.Datüjâtâ@âCâïé╠ô╟é▌ì₧é▌é╔Ä╕ösé╡é▄é╡é╜üI\n");
  2102.     return 0;
  2103.   }
  2104.  
  2105.   /* FileLength check */
  2106.  
  2107.   for (i=0;i<=BgmCnt-1;i++) {
  2108.     if ((FilePtr = fopen(BgmFile[i],"rb")) != NULL) {
  2109.       BgmSize[i] = filelength(fileno(FilePtr));
  2110.       if (((unsigned char *)BgmPtr[i]=(unsigned char *)malloc(BgmSize[i])) == NULL) {
  2111.         printf("éaéfélâtâ@âCâïüi%süjé╠âüâéâèèmò█é╔Ä╕ösé╡é▄é╡é╜üI\n",BgmFile[i]);
  2112.         return 0;
  2113.       } else {
  2114.         printf("%s é≡ %d éaéÖéöéàô╟é▌ì₧é±é┼é▄é╖üB\n",BgmFile[i],BgmSize[i]);
  2115.         fread(BgmPtr[i],1,BgmSize[i],FilePtr);
  2116.         fclose(FilePtr);
  2117.       }
  2118.     } else {
  2119.      printf("éaéfélâtâ@âCâïüi%süjé╠ô╟é▌ì₧é▌é╔Ä╕ösé╡é▄é╡é╜üBBgm.Daté≡Æ▓é╫é─ë║é│éóüI\n",BgmFile[i]);
  2120.      return 0; 
  2121.     }
  2122.   }
  2123.   return -1;
  2124. }
  2125.  
  2126. static char
  2127. Bgm(unsigned char i)
  2128. {
  2129. /*  int hOpm;
  2130.  
  2131.   unsigned char *FileName = "OPM";
  2132.  
  2133.   hOpm = OPEN(FileName,0x001);
  2134.   WRITE(hOpm,BgmPtr[i],BgmSize[i]);
  2135.   CLOSE(hOpm);
  2136.  
  2137.   return -1;
  2138. */
  2139.  
  2140.   BgmStop();
  2141.  
  2142.   BgmPlay(BgmSize[i],BgmPtr[i]);
  2143.  
  2144.   return -1;
  2145.  
  2146.  
  2147. }
  2148.  
  2149. static char
  2150. SeRead(void)
  2151. {
  2152.   FILE *FilePtr;
  2153.   unsigned char Str[256];
  2154.   char          *From;
  2155.   char          *To;
  2156.   unsigned char i;
  2157.   unsigned char j;
  2158.   char          *Addr;
  2159.   unsigned char SeCnt=0;
  2160.   unsigned char SeFile[128][32];
  2161.  
  2162.  
  2163.   FilePtr = fopen("Se.dat","rt");
  2164.  
  2165.   if (FilePtr != NULL) {
  2166.     i=0;
  2167.     while (!feof(FilePtr)) {
  2168.       fgets(Str,256,FilePtr);      /* 1 line read */
  2169.         From=strrchr(Str,'<');
  2170.         To  =strrchr(Str,'>');
  2171.         if (From != NULL && To != NULL) {
  2172.           j=0;
  2173.           for (Addr=From+1;Addr<=To-1;Addr++) {
  2174.             SeFile[i][j]=*(char *)Addr;
  2175.             j++;
  2176.           }
  2177.           SeFile[i][j] = 0;  /* end code insert */ 
  2178.           SeFile[i][j+1] = 0;  /* end code insert */ 
  2179.           i++;
  2180.           SeCnt++;
  2181.         }
  2182.     }
  2183.     fclose (FilePtr);
  2184.   } else {
  2185.     printf("érédÆΦï`üiSe.Datüjâtâ@âCâïé╠ô╟é▌ì₧é▌é╔Ä╕ösé╡é▄é╡é╜üI\n");
  2186.     return 0;
  2187.   }
  2188.  
  2189.   /* FileLength check */
  2190.  
  2191.   for (i=0;i<=SeCnt-1;i++) {
  2192.     if ((FilePtr = fopen(SeFile[i],"rb")) != NULL) {
  2193.       SeSize[i] = filelength(fileno(FilePtr));
  2194.       if (((unsigned char *)SePtr[i]=(unsigned char *)malloc(SeSize[i])) == NULL) {
  2195.         printf("érédâtâ@âCâïüi%süjé╠âüâéâèèmò█é╔Ä╕ösé╡é▄é╡é╜üI\n",SeFile[i]);
  2196.         return 0;
  2197.       } else {
  2198.         printf("%s é≡ %d éaéÖéöéàô╟é▌ì₧é±é┼é▄é╖üB\n",SeFile[i],SeSize[i]);
  2199.         fread(SePtr[i],1,SeSize[i],FilePtr);
  2200.         fclose(FilePtr);
  2201.       }
  2202.     } else {
  2203.      printf("érédâtâ@âCâïüi%süjé╠ô╟é▌ì₧é▌é╔Ä╕ösé╡é▄é╡é╜üBSe.Daté≡Æ▓é╫é─ë║é│éóüI\n",SeFile[i]);
  2204.      return 0; 
  2205.     }
  2206.   }
  2207.   return -1;
  2208. }
  2209.  
  2210. static void
  2211. Se(unsigned char i)
  2212. {
  2213. /*
  2214.   if (ADPCMSNS()==0x02)  ADPCMMOD(00);
  2215.   ADPCMOUT(SePtr[i],0x0403,SeSize[i]);
  2216.  
  2217. */
  2218.  
  2219.   SePlay(8,(SePtr[i]+10));
  2220.  
  2221. }
  2222.  
  2223.  
  2224.  
  2225.  
  2226. /*  End Program   */
  2227. 
  2228.